Celestin Apprentice 7

home *** CD-ROM | disk | FTP | other *** search

/ Celestin Apprentice 7 / Apprentice-Release7.iso / Environments / PowerLisp 2.01 / Supplemental Documentation / Documentation / Chapter 01. Introduction < prev next >

Wrap

Text File | 1995-03-27 | 25.9 KB | 574 lines | [TEXT/ROSA]

Common Lisp the Language, 2nd Edition ------------------------------------------------------------------------------- 1. Introduction Common Lisp is a new dialect of Lisp, a successor to MacLisp [33,37], influenced strongly by Zetalisp [55,34] and to some extent by Scheme [46] and Interlisp [50]. ------------------------------------------------------------------------------- * Purpose * Notational Conventions o Decimal Numbers o Nil, False, and the Empty List o Evaluation, Expansion, and Equivalence o Errors o Descriptions of Functions and Other Entities o The Lisp Reader o Overview of Syntax ------------------------------------------------------------------------------- 1.1. Purpose Common Lisp is intended to meet these goals: Commonality Common Lisp originated in an attempt to focus the work of several implementation groups, each of which was constructing successor implementations of MacLisp for different computers. These implementations had begun to diverge because of the differences in the implementation environments: microcoded personal computers (Zetalisp, Spice Lisp), commercial timeshared computers (NIL-the ``New Implementation of Lisp''), and supercomputers (S-1 Lisp). While the differences among the several implementation environments of necessity will continue to force certain incompatibilities among the implementations, Common Lisp serves as a common dialect to which each implementation makes any necessary extensions. Portability Common Lisp intentionally excludes features that cannot be implemented easily on a broad class of machines. On the one hand, features that are difficult or expensive to implement on hardware without special microcode are avoided or provided in a more abstract and efficiently implementable form. (Examples of this are the invisible forwarding pointers and locatives of Zetalisp. Some of the problems that they solve are addressed in different ways in Common Lisp.) On the other hand, features that are useful only on certain ``ordinary'' or ``commercial'' processors are avoided or made optional. (An example of this is the type declaration facility, which is useful in some implementations and completely ignored in others. Type declarations are completely optional and for correct programs affect only efficiency, not semantics.) Common Lisp is designed to make it easy to write programs that depend as little as possible on machine-specific characteristics, such as word length, while allowing some variety of implementation techniques. Consistency Most Lisp implementations are internally inconsistent in that by default the interpreter and compiler may assign different semantics to correct programs. This semantic difference stems primarily from the fact that the interpreter assumes all variables to be dynamically scoped, whereas the compiler assumes all variables to be local unless explicitly directed otherwise. This difference has been the usual practice in Lisp for the sake of convenience and efficiency but can lead to very subtle bugs. The definition of Common Lisp avoids such anomalies by explicitly requiring the interpreter and compiler to impose identical semantics on correct programs so far as possible. Expressiveness Common Lisp culls what experience has shown to be the most useful and understandable constructs from not only MacLisp but also Interlisp, other Lisp dialects, and other programming languages. Constructs judged to be awkward or less useful have been excluded. (An example is the store construct of MacLisp.) Compatibility Unless there is a good reason to the contrary, Common Lisp strives to be compatible with Lisp Machine Lisp, MacLisp, and Interlisp, roughly in that order. Efficiency Common Lisp has a number of features designed to facilitate the production of high-quality compiled code in those implementations whose developers care to invest effort in an optimizing compiler. One implementation of Common Lisp, namely S-1 Lisp, already has a compiler that produces code for numerical computations that is competitive in execution speed to that produced by a Fortran compiler [11]. The S-1 Lisp compiler extends the work done in MacLisp to produce extremely efficient numerical code [19]. Power Common Lisp is a descendant of MacLisp, which has traditionally placed emphasis on providing system-building tools. Such tools may in turn be used to build the user-level packages such as Interlisp provides; these packages are not, however, part of the Common Lisp core specification. It is expected such packages will be built on top of the Common Lisp core. Stability It is intended that Common Lisp will change only slowly and with due deliberation. The various dialects that are supersets of Common Lisp may serve as laboratories within which to test language extensions, but such extensions will be added to Common Lisp only after careful examination and experimentation. The goals of Common Lisp are thus very close to those of Standard Lisp [31] and Portable Standard Lisp [51]. Common Lisp differs from Standard Lisp primarily in incorporating more features, including a richer and more complicated set of data types and more complex control structures. This book is intended to be a language specification rather than an implementation specification (although implementation notes are scattered throughout the text). It defines a set of standard language concepts and constructs that may be used for communication of data structures and algorithms in the Common Lisp dialect. This set of concepts and constructs is sometimes referred to as the ``core Common Lisp language'' because it contains conceptually necessary or important features. It is not necessarily implementationally minimal. While many features could be defined in terms of others by writing Lisp code, and indeed may be implemented that way, it was felt that these features should be conceptually primitive so that there might be agreement among all users as to their usage. (For example, bignums and rational numbers could be implemented as Lisp code given operations on fixnums. However, it is important to the conceptual integrity of the language that they be regarded by the user as primitive, and they are useful enough to warrant a standard definition.) For the most part, this book defines a programming language, not a programming environment. A few interfaces are defined for invoking such standard programming tools as a compiler, an editor, a program trace facility, and a debugger, but very little is said about their nature or operation. It is expected that one or more extensive programming environments will be built using Common Lisp as a foundation, and will be documented separately. [change_begin] There are now many implementations of Common Lisp, some programmed by research groups in universities and some by companies that sell them commercially, and a number of useful programming environments have indeed grown up around these implementations. What is more, all the goals stated above have been achieved, most notably that of portability. Moving large bodies of Lisp code from one computer to another is now routine. [change_end] 1.2. Notational Conventions A number of special notational conventions are used throughout this book for the sake of conciseness. ------------------------------------------------------------------------------- * Decimal Numbers * Nil, False, and the Empty List * Evaluation, Expansion, and Equivalence * Errors * Descriptions of Functions and Other Entities * The Lisp Reader * Overview of Syntax ------------------------------------------------------------------------------- 1.2.1. Decimal Numbers All numbers in this book are in decimal notation unless there is an explicit indication to the contrary. (Decimal notation is normally taken for granted, of course. Unfortunately, for certain other dialects of Lisp, MacLisp in particular, the default notation for numbers is octal (base 8) rather than decimal, and so the use of decimal notation for describing Common Lisp is, taken in its historical context, a bit unusual!) 1.2.2. Nil, False, and the Empty List In Common Lisp, as in most Lisp dialects, the symbol nil is used to represent both the empty list and the ``false'' value for Boolean tests. An empty list may, of course, also be written (); this normally denotes the same object as nil. (It is possible, by extremely perverse manipulation of the package system, to cause the sequence of letters nil to be recognized not as the symbol that represents the empty list but as another symbol with the same name. This obscure possibility will be ignored in this book.) These two notations may be used interchangeably as far as the Lisp system is concerned. However, as a matter of style, this book uses the notation () when it is desirable to emphasize the use of an empty list, and uses the notation nil when it is desirable to emphasize the use of the Boolean ``false''. The notation 'nil (note the explicit quotation mark) is used to emphasize the use of a symbol. For example: (defun three () 3) ;Emphasize empty parameter list (append '() '()) => () ;Emphasize use of empty lists (not nil) => t ;Emphasize use as Boolean ``false'' (get 'nil 'color) ;Emphasize use as a symbol Any data object other than nil is construed to be Boolean ``not false'', that is, ``true''. The symbol t is conventionally used to mean ``true'' when no other value is more appropriate. When a function is said to ``return false'' or to ``be false'' in some circumstance, this means that it returns nil. However, when a function is said to ``return true'' or to ``be true'' in some circumstance, this means that it returns some value other than nil, but not necessarily t. 1.2.3. Evaluation, Expansion, and Equivalence Execution of code in Lisp is called evaluation because executing a piece of code normally results in a data object called the value produced by the code. The symbol => is used in examples to indicate evaluation. For example, (+ 4 5) => 9 means ``the result of evaluating the code (+ 4 5) is (or would be, or would have been) 9.'' The symbol -> is used in examples to indicate macro expansion. For example, (push x v) -> (setf v (cons x v)) means ``the result of expanding the macro-call form (push x v) is (setf v (cons x v)).'' This implies that the two pieces of code do the same thing; the second piece of code is the definition of what the first does. The symbol == is used in examples to indicate code equivalence. For example, (gcd x (gcd y z)) == (gcd (gcd x y) z) means ``the value and effects of evaluating the form (gcd x (gcd y z)) are always the same as the value and effects of (gcd (gcd x y) z) for any values of the variables x, y, and z.'' This implies that the two pieces of code do the same thing; however, neither directly defines the other in the way macro expansion does. 1.2.4. Errors When this book specifies that it ``is an error'' for some situation to occur, this means that: * No valid Common Lisp program should cause this situation to occur. * If this situation occurs, the effects and results are completely undefined as far as adherence to the Common Lisp specification is concerned. * No Common Lisp implementation is required to detect such an error. Of course, implementors are encouraged to provide for detection of such errors wherever reasonable. This is not to say that some particular implementation might not define the effects and results for such a situation; the point is that no program conforming to the Common Lisp specification may correctly depend on such effects or results. On the other hand, if it is specified in this book that in some situation ``an error is signaled,'' this means that: * If this situation occurs, an error will be signaled (see error and cerror). * Valid Common Lisp programs may rely on the fact that an error will be signaled. * Every Common Lisp implementation is required to detect such an error. In places where it is stated that so-and-so ``must'' or ``must not'' or ``may not'' be the case, then it ``is an error'' if the stated requirement is not met. For example, if an argument ``must be a symbol,'' then it ``is an error'' if the argument is not a symbol. In all cases where an error is to be signaled, the word ``signaled'' is always used explicitly in this book. [change_begin] X3J13 has adopted a more elaborate terminology for errors, and has made some effort to specify the type of error to be signaled in situations where signaling is appropriate. This effort was not complete as of September 1989, and I have made little attempt to incorporate the new error terminology or error type specifications in this book. However, the new terminology is described and used in the specification of the Common Lisp Object System appearing in chapter 28; this gives the flavor of how erroneous situations will be described, and appropriate actions prescribed, in the forthcoming ANSI Common Lisp standard. [change_end] 1.2.5. Descriptions of Functions and Other Entities Functions, variables, named constants, special forms, and macros are described using a distinctive typographical format. Table 1-1 illustrates the manner in which Common Lisp functions are documented. The first line specifies the name of the function, the manner in which it accepts arguments, and the fact that it is a function. If the function takes many arguments, then the names of the arguments may spill across two or three lines. The paragraphs following this standard header explain the definition and uses of the function and often present examples or related functions. Sometimes two or more related functions are explained in a single combined description. In this situation the headers for all the functions appear together, followed by the combined description. In general, actual code (including actual names of functions) appears in this typeface: (cons a b). Names that stand for pieces of code (metavariables) are written in italics. In a function description, the names of the parameters appear in italics for expository purposes. The word &optional in the list of parameters indicates that all arguments past that point are optional; the default values for the parameters are described in the text. Parameter lists may also contain &rest, indicating that an indefinite number of arguments may appear, or &key, indicating that keyword arguments are accepted. (The &optional/&rest/&key syntax is actually used in Common Lisp function definitions for these purposes.) ---------------------------------------------------------------- Table 1-1: Sample Function Description [Function] sample-function arg1 arg2 &optional arg3 arg4 The function sample-function adds together arg1 and arg2, and then multiplies the result by arg3. If arg3 is not provided or is nil, the multiplication isn't done. sample-function then returns a list whose first element is this result and whose section element is arg4 (which defaults to the symbol foo). For example: (sample-function 3 4) => (7 foo) (sample-function 1 2 2 'bar) => (6 bar) In general, (sample-function x y) == (list (+ x y) 'foo). ---------------------------------------------------------------- ---------------------------------------------------------------- Table 1-2: Sample Variable Description [Variable] *sample-variable* The variable *sample-variable* specifies how many times the special form sample-special-form should iterate. The value should always be a non-negative integer or nil (which means iterate indefinitely many times). The initial value is 0 (meaning no iterations). ---------------------------------------------------------------- ---------------------------------------------------------------- Table 1-3: Sample Constant Description [Constant] sample-constant The named constant sample-constant has as its value the height of the terminal screen in furlongs times the base-2 logarithm of the implementation's total disk capacity in bytes, as a floating-point number. ---------------------------------------------------------------- Table 1-2 illustrates the manner in which a global variable is documented. The first line specifies the name of the variable and the fact that it is a variable. Purely as a matter of convention, all global variables used by Common Lisp have names beginning and ending with an asterisk. Table 1-3 illustrates the manner in which a named constant is documented. The first line specifies the name of the constant and the fact that it is a constant. (A constant is just like a global variable, except that it is an error ever to alter its value or to bind it to a new value.) ---------------------------------------------------------------- Table 1-4: Sample Special Form Description [Special Form] sample-special-form [name] ({var}*) {form}+ This evaluates each form in sequence as an implicit progn, and does this as many times as specified by the global variable *sample-variable*. Each variable var is bound and initialized to 43 before the first iteration, and unbound after the last iteration. The name name, if supplied, may be used in a return-from form to exit from the loop prematurely. If the loop ends normally, sample-special-form returns nil. For example: (setq *sample-variable* 3) (sample-special-form () form1 form2) This evaluates form1, form2, form1, form2, form1, form2, in that order. ---------------------------------------------------------------- ---------------------------------------------------------------- Table 1-5: Sample Macro Description [Macro] sample-macro var [[ declaration* | doc-string ]] {tag | statement}* This evaluates the statements as a prog body, with the variable var bound to 43. (sample-macro x (return (+ x x))) => 86 (sample-macro var . body) -> (prog ((var 43)) . body) ---------------------------------------------------------------- Tables 1-4 and 1-5 illustrate the documentation of special forms and macros, which are closely related in purpose. These are very different from functions. Functions are called according to a single, specific, consistent syntax; the &optional/&rest/&key syntax specifies how the function uses its arguments internally but does not affect the syntax of a call. In contrast, each special form or macro can have its own idiosyncratic syntax. It is by special forms and macros that the syntax of Common Lisp is defined and extended. In the description of a special form or macro, an italicized word names a corresponding part of the form that invokes the special form or macro. Parentheses stand for themselves and should be written as such when invoking the special form or macro. Brackets, braces, stars, plus signs, and vertical bars are metasyntactic marks. Brackets, [ and ], indicate that what they enclose is optional (may appear zero times or one time in that place); the square brackets should not be written in code. Braces, { and }, simply parenthesize what they enclose but may be followed by a star, *, or a plus sign, +; a star indicates that what the braces enclose may appear any number of times (including zero, that is, not at all), whereas a plus sign indicates that what the braces enclose may appear any non-zero number of times (that is, must appear at least once). Within braces or brackets, a vertical bar, |, separates mutually exclusive choices. In summary, the notation {x}* means zero or more occurrences of x, the notation {x}+ means one or more occurrences of x, and the notation [x] means zero or one occurrence of x. These notations are also used for syntactic descriptions expressed as BNF-like productions, as in table 22-2. [change_begin] Double brackets, [[ and ]], indicate that any number of the alternatives enclosed may be used, and those used may occur in any order, but each alternative may be used at most once unless followed by a star. For example, p [[x | {y}* | z]] q means that at most one x, any number of y's, and at most one z may appear between the mandatory occurrences of p and q, and those that appear may be in any order. A downward arrow, [?], indicates a form of syntactic indirection that helps to make [[ ]] notation more readable. If X is some non-terminal symbol occurring on the left-hand side of some BNF production, then the right-hand side of that production is to be textually substituted for any occurrence of [?]X. Thus the two fragments p [[[?]xyz-mixture]] q xyz-mixture ::= x | {y}* | z are together equivalent to the previous example. [change_end] In the last example in table 1-5, notice the use of dot notation. The dot appearing in the expression (sample-macro var . body) means that the name body stands for a list of forms, not just a single form, at the end of a list. This notation is often used in examples. [change_begin] In the heading line in table 1-5, notice the use of [[ ]] notation to indicate that any number of declarations may appear but at most one documentation string (which may appear before, after, or somewhere in the middle of any declarations). [change_end] 1.2.6 The Lisp Reader The term ``Lisp reader'' refers not to you, the reader of this book, nor to some person reading Lisp code, but specifically to a Lisp procedure, namely the function read, which reads characters from an input stream and interprets them by parsing as representations of Lisp objects. 1.2.7. Overview of Syntax Certain characters are used in special ways in the syntax of Common Lisp. The complete syntax is explained in detail in chapter 22, but a quick summary here may be useful: ( A left parenthesis begins a list of items. The list may contain any number of items, including zero. Lists may be nested. For example, (cons (car x) (cdr y)) is a list of three things, of which the last two are themselves lists. ) A right parenthesis ends a list of items. ' An acute accent (also called single quote or apostrophe) followed by an expression form is an abbreviation for (quote form). Thus 'foo means (quote foo) and '(cons 'a 'b) means (quote (cons (quote a) (quote b))). ; Semicolon is the comment character. It and all characters up to the end of the line are discarded. " Double quotes surround character strings: "This is a thirty-nine-character string." \ Backslash is an escape character. It causes the next character to be treated as a letter rather than for its usual syntactic purpose. For example, A\(B denotes a symbol whose name consists of the three characters A, (, and B. Similarly, "\"" denotes a character string containing one character, a double quote, because the first and third double quotes serve to delimit the string, and the second double quote serves as the contents of the string. The backslash causes the second double quote to be taken literally and prevents it from being interpreted as the terminating delimiter of the string. | Vertical bars are used in pairs to surround the name (or part of the name) of a symbol that has many special characters in it. It is roughly equivalent to putting a backslash in front of every character so surrounded. For example, |A(B)|, A|(|B|)|, and A\(B\) all mean the symbol whose name consists of the four characters A, (, B, and ). # The number sign signals the beginning of a complicated syntactic structure. The next character designates the precise syntax to follow. For example, #o105 means (105 in octal notation); #x105 means (105 in hexadecimal notation); #b1011 means (1011 in binary notation); #\L denotes a character object for the character L; and #(a b c) denotes a vector of three elements a, b, and c. A particularly important case is that #'fn means (function fn), in a manner analogous to 'form meaning (quote form). ` Grave accent (``backquote'') signals that the next expression is a template that may contain commas. The backquote syntax represents a program that will construct a data structure according to the template. , Commas are used within the backquote syntax. : Colon is used to indicate which package a symbol belongs to. For example, network:reset denotes the symbol named reset in the package named network. A leading colon indicates a keyword, a symbol that always evaluates to itself. The colon character is not actually part of the print name of the symbol. This is all explained in chapter 11; until you read that, just keep in mind that a symbol notated with a leading colon is in effect a constant that evaluates to itself. [change_begin] Notice of correction. In the first edition, the characters ``,'' and ``:'' at the left margin above were inadvertently omitted. [change_end] Brackets, braces, question mark, and exclamation point (that is, [, ], {, }, ?, and !) are not used for any purpose in standard Common Lisp syntax. These characters are explicitly reserved to the user, primarily for use as macro characters for user-defined lexical syntax extensions (see section 22.1.3). [old_change_begin] All code in this book is written using lowercase letters. Common Lisp is generally insensitive to the case in which code is written. Internally, names of symbols are ordinarily converted to and stored in uppercase form. There are ways to force case conversion on output if desired; see *print-case*. In this book, wherever an interactive exchange between a user and the Lisp system is shown, the input is exhibited with lowercase letters and the output with uppercase letters. [old_change_end] [change_begin] X3J13 voted in June 1989 (READ-CASE-SENSITIVITY) to introduce readtable-case. Certain settings allow the names of symbols to be case-sensitive. The default behavior, however, is as described in the previous paragraph. In any event, only uppercase letters appear in the internal print names of symbols naming the standard Common Lisp facilities described in this book. [change_end]